home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 April / EnigmA AMIGA RUN 17 (1997)(G.R. Edizioni)(IT)[!][issue 1997-04][EAR-CD].iso / EARCD / comm / term / term_47a_pch.lha / Source / gtlayout-38.3 / LT_HandleInput.c < prev    next >
C/C++ Source or Header  |  1996-11-10  |  44KB  |  2,026 lines
  1. /*
  2. **    GadTools layout toolkit
  3. **
  4. **    Copyright © 1993-1996 by Olaf `Olsen' Barthel
  5. **        Freely distributable.
  6. **
  7. **    :ts=4
  8. */
  9.  
  10. #ifndef _GTLAYOUT_GLOBAL_H
  11. #include "gtlayout_global.h"
  12. #endif
  13.  
  14. STATIC LONG
  15. CurrentWrap(ObjectNode *Node,LONG Current)
  16. {
  17.     if(Current > Node->Max)
  18.         Current = Node->Min;
  19.     else
  20.     {
  21.         if(Current < Node->Min)
  22.             Current = Node->Max;
  23.     }
  24.  
  25.     return(Current);
  26. }
  27.  
  28. STATIC BOOL
  29. CurrentInBounds(ObjectNode *Node,LONG Current)
  30. {
  31.     return((BOOL)(Node->Min <= Current && Current <= Node->Max && Current != Node->Current));
  32. }
  33.  
  34. /****** gtlayout.library/LT_HandleInput ******************************************
  35. *
  36. *   NAME
  37. *    LT_HandleInput -- Filter IntuiMessage data.
  38. *
  39. *   SYNOPSIS
  40. *    LT_HandleInput(Handle,Qualifier,Class,Code,Gadget);
  41. *                     A0      D0      A1    A2    A3
  42. *
  43. *    VOID LT_HandleInput(LayoutHandle *,ULONG,ULONG *,
  44. *                        UWORD *,struct Gadget **);
  45. *
  46. *   FUNCTION
  47. *    In order to keep track of user interface actions, such as
  48. *    keys getting pressed, sliders getting moved, etc. your
  49. *    code is to call LT_HandleInput() with data copied from the
  50. *    IntuiMessage it has just received and replied.
  51. *
  52. *   INPUTS
  53. *    Handle - Pointer to a LayoutHandle structure.
  54. *
  55. *    Qualifier - The Qualifier value copied from the
  56. *        IntuiMessage structure.
  57. *
  58. *    Class - Pointer to the ULONG variable which holds the
  59. *        value copied from the Class entry of the
  60. *        IntuiMessage structure.
  61. *
  62. *    Code - Pointer to the UWORD variable which holds the
  63. *        value copied from the Code entry of the
  64. *        IntuiMessage structure.
  65. *
  66. *    Gadget - Pointer to the Gadget value copied from the
  67. *        IAddress entry of the IntuiMessage structure.
  68. *
  69. *   RESULT
  70. *    none
  71. *
  72. *   EXAMPLE
  73. *    struct IntuiMessage *IntuiMessage;
  74. *    ULONG Qualifier,Class;
  75. *    UWORD Code;
  76. *    struct Gadget *Gadget;
  77. *
  78. *    for(;;)
  79. *    {
  80. *        WaitPort(Window->UserPort);
  81. *
  82. *        while(IntuiMessage = GT_GetIMsg(Window->UserPort))
  83. *        {
  84. *            Class = IntuiMessage->Class;
  85. *            Code = IntuiMessage->Code;
  86. *            Qualifier = IntuiMessage->Qualifier;
  87. *            Gadget = IntuiMessage->Gadget;
  88. *
  89. *            GT_ReplyIMsg(IntuiMessage);
  90. *
  91. *            LT_HandleInput(Handle,Qualifier,&Class,&Code,&Gadget);
  92. *        }
  93. *    }
  94. *
  95. *   NOTES
  96. *    For BOOPSI_KIND objects keystroke activation may lead to
  97. *    unexpected results. Your application will hear a IDCMP_GADGETUP
  98. *    event, the IntuiMessage->Code value will hold the ANSI key
  99. *    code of the key the user pressed.
  100. *
  101. *    Do not call this routine before you have actually
  102. *    replied the IntuiMessage received or weird things
  103. *    may happen. This is not a suggestion, it's a threat.
  104. *
  105. ******************************************************************************
  106. *
  107. */
  108.  
  109. VOID LIBENT
  110. LT_HandleInput(REG(a0) LayoutHandle *Handle,REG(d0) ULONG MsgQualifier,REG(a1) ULONG *MsgClass,REG(a2) UWORD *MsgCode,REG(a3) struct Gadget **MsgGadget)
  111. {
  112.     ObjectNode *Node;
  113.     BOOL Activate;
  114.  
  115.     if(!Handle)
  116.         return;
  117.  
  118.     if(Handle->Failed)
  119.     {
  120.         *MsgClass = IDCMP_CLOSEWINDOW;
  121.  
  122.         if(!Handle->NeedDelay)
  123.             Handle->NeedDelay = TRUE;
  124.         else
  125.             LTP_Delay(0,500000);    // Give the guy a break
  126.  
  127.         return;
  128.     }
  129.  
  130.     Activate = FALSE;
  131.  
  132.     switch(*MsgClass)
  133.     {
  134.         case IDCMP_CHANGEWINDOW:
  135.  
  136.             if(!(Handle->Window->Flags & WFLG_SIZEGADGET) && (Handle->Window->Flags & WFLG_HASZOOM) && !V39)
  137.             {
  138. #ifdef DO_BOOPSI_KIND
  139.                 if(Handle->BOOPSIList)
  140.                     RefreshGList((struct Gadget *)Handle->BOOPSIList,Handle->Window,NULL,(UWORD)-1);
  141. #endif    /* DO_BOOPSI_KIND */
  142.  
  143.                 RefreshGList(Handle->List,Handle->Window,NULL,(UWORD)-1);
  144.  
  145.                 GT_RefreshWindow(Handle->Window,NULL);
  146.  
  147.                 LTP_DrawGroup(Handle,Handle->TopGroup);
  148.             }
  149.  
  150.             break;
  151.  
  152.         case IDCMP_NEWSIZE:
  153.  
  154.                 // Did the user cancel the resize operation?
  155.  
  156.             if(Handle->SizeVerified && Handle->SizeWidth == Handle->Window->Width && Handle->SizeHeight == Handle->Window->Height)
  157.             {
  158.                 Handle->SizeVerified    = FALSE;
  159.                 Handle->SizeWidth    = 0;
  160.                 Handle->SizeHeight    = 0;
  161.  
  162.                     // Put the gadgets back in
  163.  
  164.                 AddGList(Handle->Window,Handle->List,(UWORD)-1,(UWORD)-1,NULL);
  165.             }
  166.             else
  167.             {
  168.                 struct IBox Box;
  169.  
  170.                 Handle->SizeWidth    = 0;
  171.                 Handle->SizeHeight    = 0;
  172.  
  173.                 Box.Left    = 0;
  174.                 Box.Top        = 0;
  175.                 Box.Width    = Handle->Window->Width;
  176.                 Box.Height    = Handle->Window->Height;
  177.  
  178.                 LT_LockWindow(Handle->Window);
  179.  
  180.                 if(Handle->ResizeView)
  181.                     Handle->ResizeView->Special.List.IgnoreListContents = TRUE;
  182.  
  183.                 LT_RebuildTags(Handle,TRUE,
  184.                     LAWN_Bounds,    &Box,
  185.                 TAG_DONE);
  186.  
  187.                 LT_UnlockWindow(Handle->Window);
  188.  
  189.                 if(Handle->Failed)
  190.                     *MsgClass = IDCMP_CLOSEWINDOW;
  191.                 else
  192.                     *MsgClass = NULL;
  193.             }
  194.  
  195.             break;
  196.  
  197.         case IDCMP_REFRESHWINDOW:
  198.  
  199.             if(Handle->AutoRefresh)
  200.             {
  201.                 LT_BeginRefresh(Handle);
  202.  
  203.                 LT_EndRefresh(Handle,TRUE);
  204.  
  205.                 *MsgClass = NULL;
  206.             }
  207.  
  208.             break;
  209.  
  210.         case IDCMP_INTUITICKS:
  211.  
  212.             if(Handle->ActiveIncrementer)
  213.             {
  214.                 if(Handle->IncrementerCountdown > 0)
  215.                     Handle->IncrementerCountdown--;
  216.  
  217.                 if(Handle->IncrementerCountdown <= 0)
  218.                 {
  219.                     if(Handle->ActiveIncrementer->Host->Flags & GFLG_SELECTED)
  220.                     {
  221.                         if(Handle->ActiveIncrementer->Type == TAPEDECK_KIND)
  222.                         {
  223.                             *MsgClass    = IDCMP_GADGETUP;
  224.                             *MsgCode    = 0;
  225.                             *MsgGadget    = Handle->ActiveIncrementer->Host;
  226.                         }
  227.                         else
  228.                         {
  229.                             ObjectNode *Parent;
  230.                             LONG Number;
  231.  
  232.                             if(Handle->IncrementerAccelerate > 0 && !(MsgQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
  233.                                 Handle->IncrementerAccelerate--;
  234.  
  235.                             if(Handle->IncrementerAccelerate <= 0)
  236.                             {
  237.                                 Handle->IncrementerAccelerate = 10;
  238.  
  239.                                 Handle->IncrementerIncrement *= 2;
  240.                             }
  241.  
  242.                             *MsgClass    = IDCMP_GADGETUP;
  243.                             *MsgCode    = 0;
  244.                             *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  245.  
  246.                             Parent = (*MsgGadget)->UserData;
  247.  
  248.                             if(Parent->Special.Integer.IncrementerHook)
  249.                                 Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),Handle->ActiveIncrementer->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  250.                             else
  251.                                 Number = ((LONG)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE)) + Handle->ActiveIncrementer->Special.Incrementer.Amount * Handle->IncrementerIncrement;
  252.  
  253.                             if(Number < Parent->Min)
  254.                                 Number = Parent->Min;
  255.                             else
  256.                             {
  257.                                 if(Number > Parent->Max)
  258.                                     Number = Parent->Max;
  259.                             }
  260.  
  261.                             LT_SetAttributes(Handle,Parent->ID,
  262.                                 LAPR_Object,    Parent,
  263.                                 GTIN_Number,    Number,
  264.                             TAG_DONE);
  265.                         }
  266.                     }
  267.                     else
  268.                     {
  269.                         Handle->IncrementerIncrement    = 1;
  270.                         Handle->IncrementerAccelerate    = 10;
  271.                     }
  272.  
  273.                     if(Handle->IncrementerIncrement == 1)
  274.                         Handle->IncrementerCountdown = 2;
  275.                 }
  276.             }
  277.  
  278.             break;
  279.  
  280.         case IDCMP_RAWKEY:
  281.         {
  282.             UBYTE Buffer[10];
  283.             LONG Key;
  284.             struct InputEvent event;
  285.             BOOL KeyUp;
  286.  
  287.             if((*MsgCode & ~IECODE_UP_PREFIX) == 95 && Handle->HelpHook)
  288.             {
  289.                 if(!(*MsgCode & IECODE_UP_PREFIX))
  290.                 {
  291.                     ObjectNode *Item;
  292.                     struct HelpMsg Message;
  293.                     struct IBox Box;
  294.  
  295.                     Item = LTP_FindNode_Position(Handle->TopGroup,Handle->Window->MouseX,Handle->Window->MouseY);
  296.  
  297.                     if(Item == Handle->TopGroup)
  298.                     {
  299.                         if(Item->ID <= PHANTOM_GROUP_ID)
  300.                             Item = NULL;
  301.                     }
  302.  
  303.                     if(Item)
  304.                     {
  305.                         Message.ObjectID = Item->ID;
  306.  
  307.                         Box.Left    = Item->Left;
  308.                         Box.Top        = Item->Top;
  309.                         Box.Width    = Item->Width;
  310.                         Box.Height    = Item->Height;
  311.                     }
  312.                     else
  313.                     {
  314.                         Message.ObjectID = -1;
  315.  
  316.                         Box.Left    = 0;
  317.                         Box.Top        = 0;
  318.                         Box.Width    = Handle->Window->Width;
  319.                         Box.Height    = Handle->Window->Height;
  320.                     }
  321.  
  322.                     Message.Handle = Handle;
  323.  
  324.                     CallHookPkt(Handle->HelpHook,&Message,&Box);
  325.                 }
  326.  
  327.                 if(Handle->RawKeyFilter)
  328.                     *MsgClass = NULL;
  329.  
  330.                 break;
  331.             }
  332.  
  333.             if((*MsgCode >= 99 && *MsgCode <= 103) || *MsgCode == 96 || *MsgCode == 97)
  334.             {
  335.                 if(Handle->RawKeyFilter)
  336.                     *MsgClass = NULL;
  337.  
  338.                 break;
  339.             }
  340.  
  341.             event.ie_NextEvent            = NULL;
  342.             event.ie_Code                 = (*MsgCode) & ~IECODE_UP_PREFIX;
  343.             event.ie_Qualifier            = MsgQualifier & ~QUALIFIER_SHIFT;
  344.             event.ie_Class                = IECLASS_RAWKEY;
  345.             event.ie_SubClass            = 0;
  346.             event.ie_position.ie_addr    = (APTR)*MsgGadget;
  347.  
  348.             Buffer[0] = 0;
  349.  
  350.             if(MapRawKey(&event,Buffer,9,NULL) < 1)
  351.             {
  352.                 if(Handle->RawKeyFilter)
  353.                     *MsgClass = NULL;
  354.  
  355.                 break;
  356.             }
  357.  
  358.             if(!(Key = Buffer[0]))
  359.             {
  360.                 if(Handle->RawKeyFilter)
  361.                     *MsgClass = NULL;
  362.  
  363.                 break;
  364.             }
  365.  
  366.             if((*MsgCode) & IECODE_UP_PREFIX)
  367.                 KeyUp = TRUE;
  368.             else
  369.                 KeyUp = FALSE;
  370.  
  371.             if(!KeyUp && Handle->CursorKey && (*MsgCode == CURSORUP || *MsgCode == CURSORDOWN))
  372.             {
  373.                 ObjectNode *Node;
  374.                 struct Gadget *Gadget;
  375.                 LONG NewState;
  376.                 LONG CurrentTop;
  377.  
  378.                 Handle->ClickSeconds = Handle->ClickMicros = 0;
  379.  
  380.                 Node        = Handle->CursorKey;
  381.                 Gadget        = Node->Host;
  382.                 NewState    = Node->Current;
  383.  
  384.                 if(V39)
  385.                 {
  386.                     GT_GetGadgetAttrs(Gadget,Handle->Window,NULL,
  387.                         GTLV_Top,&CurrentTop,
  388.                     TAG_DONE);
  389.                 }
  390.  
  391.                 if(*MsgCode == CURSORDOWN)
  392.                 {
  393.                     if(MsgQualifier & QUALIFIER_SHIFT)
  394.                     {
  395.                         if(V39)
  396.                         {
  397.                             if(NewState != CurrentTop + Node->Lines - 1)
  398.                                 NewState = CurrentTop + Node->Lines - 1;
  399.                             else
  400.                                 NewState += Node->Lines;
  401.                         }
  402.                         else
  403.                             NewState += Node->Lines;
  404.                     }
  405.                     else
  406.                     {
  407.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  408.                             NewState = Node->Max;
  409.                         else
  410.                             NewState++;
  411.                     }
  412.                 }
  413.                 else
  414.                 {
  415.                     if(MsgQualifier & QUALIFIER_SHIFT)
  416.                     {
  417.                         if(V39)
  418.                         {
  419.                             if(NewState != CurrentTop)
  420.                                 NewState = CurrentTop;
  421.                             else
  422.                                 NewState -= Node->Lines;
  423.                         }
  424.                         else
  425.                             NewState -= Node->Lines;
  426.                     }
  427.                     else
  428.                     {
  429.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  430.                             NewState = Node->Min;
  431.                         else
  432.                             NewState--;
  433.                     }
  434.                 }
  435.  
  436.                 if(NewState < Node->Min)
  437.                     NewState = Node->Min;
  438.                 else
  439.                 {
  440.                     if(NewState > Node->Max)
  441.                         NewState = Node->Max;
  442.                 }
  443.  
  444.                 if(NewState != Node->Current || Node->Max == Node->Min)
  445.                 {
  446.                     ULONG WhichTag;
  447.  
  448.                     if(V39)
  449.                         WhichTag = GTLV_MakeVisible;
  450.                     else
  451.                         WhichTag = GTLV_Top;
  452.  
  453.                     Node->Current = NewState;
  454.  
  455.                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  456.                         WhichTag,    Node->Current,
  457.                         Node->Special.List.LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node->Current,
  458.                     TAG_DONE);
  459.  
  460.                     LTP_PutStorage(Node);
  461.  
  462.                     *MsgClass    = IDCMP_GADGETUP;
  463.                     *MsgCode    = Node->Current;
  464.                     *MsgGadget    = Gadget;
  465.  
  466.                     if(Node->Special.List.AutoPageID != -1)
  467.                         *MsgClass = NULL;
  468.  
  469.                     if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  470.                         *MsgClass = IDCMP_CLOSEWINDOW;
  471.                 }
  472.                 else
  473.                 {
  474.                     if(Handle->RawKeyFilter)
  475.                         *MsgClass = NULL;
  476.                 }
  477.  
  478.                 Handle->ActiveFrame = NULL;
  479.  
  480.                 return;
  481.             }
  482.  
  483.             if(Key == '\t' && !KeyUp)
  484.             {
  485.                 ObjectNode *Node;
  486.  
  487.                 if(Handle->RawKeyFilter)
  488.                     *MsgClass = NULL;
  489.  
  490.                 if(Node = Handle->TabKey)
  491.                 {
  492.                     if(!(Node->Disabled))
  493.                     {
  494.                         LONG Choice;
  495.  
  496.                         if(MsgQualifier & QUALIFIER_SHIFT)
  497.                             Choice = Node->Current - 1;
  498.                         else
  499.                             Choice = Node->Current + 1;
  500.  
  501.                         Choice = CurrentWrap(Node,Choice);
  502.  
  503.                         if(Choice != Node->Current)
  504.                         {
  505.                             LONG AutoPageID,Type;
  506.                             BOOL CanBlink;
  507.  
  508.                             *MsgClass = IDCMP_GADGETUP;
  509.  
  510.                             CanBlink = FALSE;
  511.  
  512.                             switch(Node->Type)
  513.                             {
  514.                                 case CYCLE_KIND:
  515.  
  516.                                     AutoPageID    = Node->Special.Cycle.AutoPageID;
  517.                                     Type        = GTCY_Active;
  518.                                     CanBlink    = TRUE;
  519.                                     break;
  520. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  521.                                 case POPUP_KIND:
  522.  
  523.                                     AutoPageID    = Node->Special.Popup.AutoPageID;
  524.                                     Type        = LAPU_Active;
  525.                                     CanBlink    = TRUE;
  526.                                     break;
  527. #endif
  528. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  529.                                 case TAB_KIND:
  530.  
  531.                                     AutoPageID    = Node->Special.Tab.AutoPageID;
  532.                                     Type        = LATB_Active;
  533.                                     break;
  534. #endif
  535.                                 case MX_KIND:
  536.  
  537.                                     AutoPageID    = Node->Special.Radio.AutoPageID;
  538.                                     Type        = GTMX_Active;
  539.  
  540.                                     *MsgClass = IDCMP_GADGETDOWN;
  541.  
  542.                                     break;
  543.                             }
  544.  
  545.                             *MsgCode    = (UWORD)Choice;
  546.                             *MsgGadget    = Node->Host;
  547.  
  548.                             if(CanBlink)
  549.                                 LTP_BlinkButton(Handle,*MsgGadget);
  550.  
  551.                             LT_SetAttributes(Handle,Node->ID,
  552.                                 Type,Choice,
  553.                             TAG_DONE);
  554.  
  555.                             if(AutoPageID != -1)
  556.                                 *MsgClass = NULL;
  557.  
  558.                             if(!LTP_NotifyPager(Handle,AutoPageID,Choice))
  559.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  560.                         }
  561.                     }
  562.                 }
  563.  
  564.                 Handle->ActiveFrame = NULL;
  565.  
  566.                 return;
  567.             }
  568.  
  569.             if(Key == '\33' && !KeyUp)
  570.             {
  571.                 ObjectNode *Node;
  572.  
  573.                 Handle->ClickSeconds = Handle->ClickMicros = 0;
  574.  
  575.                 if(Node = Handle->EscKey)
  576.                 {
  577.                     if(!Node->Disabled)
  578.                     {
  579.                         LTP_BlinkButton(Handle,Node->Host);
  580.  
  581.                         *MsgCode    = 0;
  582.                         *MsgGadget    = Node->Host;
  583.                         *MsgClass    = IDCMP_GADGETUP;
  584.                     }
  585.                     else
  586.                     {
  587.                         if(Handle->RawKeyFilter)
  588.                             *MsgClass = NULL;
  589.                     }
  590.                 }
  591.                 else
  592.                 {
  593.                     if(Handle->Window->Flags & WFLG_CLOSEGADGET)
  594.                     {
  595.                         *MsgCode    = 0;
  596.                         *MsgGadget    = NULL;
  597.                         *MsgClass    = IDCMP_CLOSEWINDOW;
  598.                     }
  599.                     else
  600.                     {
  601.                         if(Handle->RawKeyFilter)
  602.                             *MsgClass = NULL;
  603.                     }
  604.                 }
  605.  
  606.                 Handle->ActiveFrame = NULL;
  607.  
  608.                 return;
  609.             }
  610.             else
  611.             {
  612.                 struct Gadget *Gadget;
  613.                 ObjectNode *Node;
  614.                 BOOL FoundIt,Forward,Swallow;
  615.                 LONG NewValue;
  616.                 LONG i;
  617.  
  618.                 if(Handle->ReturnKey && Key == '\r')
  619.                 {
  620.                     Node = Handle->ReturnKey;
  621.  
  622.                     if(!KeyUp && !Node->Disabled)
  623.                     {
  624.                         LTP_BlinkButton(Handle,Node->Host);
  625.  
  626.                         *MsgClass    = IDCMP_GADGETUP;
  627.                         *MsgCode    = 0;
  628.                         *MsgGadget    = Node->Host;
  629.                     }
  630.                     else
  631.                     {
  632.                         if(Handle->RawKeyFilter)
  633.                             *MsgClass = NULL;
  634.                     }
  635.  
  636.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  637.  
  638.                     Handle->ActiveFrame = NULL;
  639.  
  640.                     return;
  641.                 }
  642.  
  643.                 if(MsgQualifier & QUALIFIER_SHIFT)
  644.                     Forward = FALSE;
  645.                 else
  646.                     Forward = TRUE;
  647.  
  648.                 FoundIt = FALSE;
  649.  
  650.                 for(i = 0 ; !FoundIt && i < Handle->Count ; i++)
  651.                 {
  652.                     if(Gadget = Handle->GadgetArray[i])
  653.                     {
  654.                         if(GETOBJECT(Gadget,Node))
  655.                         {
  656.                             if(Key == Node->Key)
  657.                             {
  658.                                 if(Node->Disabled)
  659.                                     break;
  660.                                 else
  661.                                 {
  662.                                     Swallow = FALSE;
  663.  
  664.                                     NewValue = Node->Current;
  665.  
  666.                                     switch(Node->Type)
  667.                                     {
  668. #ifdef DO_BOOPSI_KIND
  669.                                         case BOOPSI_KIND:
  670.  
  671.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  672.                                             {
  673.                                                 if(Node->Special.BOOPSI.ActivateHook)
  674.                                                 {
  675.                                                     if(CallHookPkt(Node->Special.BOOPSI.ActivateHook,(APTR)Handle,(APTR)Node->Host))
  676.                                                     {
  677.                                                         Swallow = TRUE;
  678.                                                         break;
  679.                                                     }
  680.                                                 }
  681.  
  682.                                                 *MsgClass    = IDCMP_GADGETUP;
  683.                                                 *MsgCode    = Forward ? 1 : (UWORD)-1;
  684.                                                 *MsgGadget    = Gadget;
  685.                                             }
  686.                                             else
  687.                                                 Swallow = TRUE;
  688.  
  689.                                             break;
  690. #ifdef DO_POPUP_KIND
  691.                                         case POPUP_KIND:
  692.  
  693.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  694.                                             {
  695.                                                 if(Forward)
  696.                                                     NewValue++;
  697.                                                 else
  698.                                                     NewValue--;
  699.  
  700.                                                 NewValue = CurrentWrap(Node,NewValue);
  701.  
  702.                                                 LTP_BlinkButton(Handle,Node->Host);
  703.  
  704.                                                 LT_SetAttributes(Handle,0,
  705.                                                     LAPR_Gadget,    Node->Host,
  706.                                                     LAPU_Active,    NewValue,
  707.                                                 TAG_DONE);
  708.  
  709.                                                 *MsgClass    = IDCMP_GADGETUP;
  710.                                                 *MsgCode    = Node->Current;
  711.                                                 *MsgGadget    = Node->Host;
  712.                                             }
  713.                                             else
  714.                                                 Swallow = TRUE;
  715.  
  716.                                             break;
  717. #endif    // DO_POPUP_KIND
  718.  
  719. #ifdef DO_TAB_KIND
  720.                                         case TAB_KIND:
  721.  
  722.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  723.                                             {
  724.                                                 if(Forward)
  725.                                                     NewValue++;
  726.                                                 else
  727.                                                     NewValue--;
  728.  
  729.                                                 NewValue = CurrentWrap(Node,NewValue);
  730.  
  731.                                                 LT_SetAttributes(Handle,0,
  732.                                                     LAPR_Gadget,    Node->Host,
  733.                                                     LAPU_Active,    NewValue,
  734.                                                 TAG_DONE);
  735.  
  736.                                                 *MsgClass    = IDCMP_GADGETUP;
  737.                                                 *MsgCode    = Node->Current;
  738.                                                 *MsgGadget    = Node->Host;
  739.                                             }
  740.                                             else
  741.                                                 Swallow = TRUE;
  742.  
  743.                                             break;
  744. #endif    // DO_TAB_KIND
  745. #endif    /* DO_BOOPSI_KIND */
  746. #ifdef DO_TAPEDECK_KIND
  747.                                         case TAPEDECK_KIND:
  748.  
  749.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  750.                                             {
  751.                                                 if(Node->Special.TapeDeck.Toggle)
  752.                                                 {
  753.                                                     LT_SetAttributes(Handle,Node->ID,
  754.                                                         LAPR_Object,    Node,
  755.                                                         LATD_Pressed,    !Node->Current,
  756.                                                     TAG_DONE);
  757.                                                 }
  758.                                                 else
  759.                                                     LTP_BlinkButton(Handle,Gadget);
  760.  
  761.                                                 if(Gadget->Flags & GFLG_SELECTED)
  762.                                                     *MsgCode = TRUE;
  763.                                                 else
  764.                                                     *MsgCode = FALSE;
  765.  
  766.                                                 *MsgClass    = IDCMP_GADGETUP;
  767.                                                 *MsgGadget    = Gadget;
  768.                                             }
  769.                                             else
  770.                                                 Swallow = TRUE;
  771.  
  772.                                             break;
  773. #endif    /* DO_TAPEDECK_KIND */
  774.                                         case CHECKBOX_KIND:
  775.  
  776.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  777.                                             {
  778.                                                 Node->Current = !Node->Current;
  779.  
  780.                                                 LTP_PutStorage(Node);
  781.  
  782.                                                 GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  783.                                                     GTCB_Checked,Node->Current,
  784.                                                 TAG_DONE);
  785.  
  786.                                                 *MsgClass    = IDCMP_GADGETUP;
  787.                                                 *MsgCode    = Node->Current;
  788.                                                 *MsgGadget    = Gadget;
  789.                                             }
  790.                                             else
  791.                                                 Swallow = TRUE;
  792.  
  793.                                             FoundIt = TRUE;
  794.  
  795.                                             break;
  796.  
  797.                                         case LISTVIEW_KIND:
  798.  
  799.                                             if(!KeyUp)
  800.                                             {
  801.                                                 if(NewValue == -1)
  802.                                                 {
  803.                                                     if(Node->Min != -1)
  804.                                                     {
  805.                                                         if(Forward)
  806.                                                             NewValue = Node->Min;
  807.                                                         else
  808.                                                             NewValue = Node->Max;
  809.                                                     }
  810.                                                 }
  811.                                                 else
  812.                                                 {
  813.                                                     if(Forward)
  814.                                                         NewValue++;
  815.                                                     else
  816.                                                         NewValue--;
  817.                                                 }
  818.  
  819.                                                 if(CurrentInBounds(Node,NewValue))
  820.                                                 {
  821.                                                     ULONG WhichTag;
  822.  
  823.                                                     if(V39)
  824.                                                         WhichTag = GTLV_MakeVisible;
  825.                                                     else
  826.                                                         WhichTag = GTLV_Top;
  827.  
  828.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  829.                                                         WhichTag,Node->Current = NewValue,
  830.                                                         Node->Special.List.LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node->Current,
  831.                                                     TAG_DONE);
  832.  
  833.                                                     LTP_PutStorage(Node);
  834.  
  835.                                                     *MsgClass    = IDCMP_GADGETUP;
  836.                                                     *MsgCode    = Node->Current;
  837.                                                     *MsgGadget    = Gadget;
  838.  
  839.                                                     if(Node->Special.List.AutoPageID != -1)
  840.                                                     {
  841.                                                         *MsgClass = NULL;
  842.  
  843.                                                         if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  844.                                                             *MsgClass = IDCMP_CLOSEWINDOW;
  845.                                                     }
  846.                                                 }
  847.                                                 else
  848.                                                     Swallow = TRUE;
  849.                                             }
  850.                                             else
  851.                                                 Swallow = TRUE;
  852.  
  853.                                             FoundIt = TRUE;
  854.  
  855.                                             break;
  856.  
  857.                                         case MX_KIND:
  858.  
  859.                                             if(!KeyUp)
  860.                                             {
  861.                                                 if(Forward)
  862.                                                     NewValue++;
  863.                                                 else
  864.                                                     NewValue--;
  865.  
  866.                                                 if(CurrentInBounds(Node,NewValue))
  867.                                                 {
  868.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  869.                                                         GTMX_Active,Node->Current = NewValue,
  870.                                                     TAG_DONE);
  871.  
  872.                                                     LTP_PutStorage(Node);
  873.  
  874.                                                     *MsgClass    = IDCMP_GADGETDOWN;
  875.                                                     *MsgCode    = Node->Current;
  876.                                                     *MsgGadget    = Gadget;
  877.  
  878.                                                     if(Node->Special.Radio.AutoPageID != -1)
  879.                                                     {
  880.                                                         *MsgClass = NULL;
  881.  
  882.                                                         if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  883.                                                             *MsgClass = IDCMP_CLOSEWINDOW;
  884.                                                     }
  885.                                                 }
  886.                                                 else
  887.                                                     Swallow = TRUE;
  888.                                             }
  889.                                             else
  890.                                                 Swallow = TRUE;
  891.  
  892.                                             FoundIt = TRUE;
  893.  
  894.                                             break;
  895.  
  896.                                         case TEXT_KIND:
  897.  
  898.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  899.                                             {
  900.                                                 if(Node->Special.Text.Picker)
  901.                                                 {
  902.                                                     LTP_BlinkButton(Handle,Node->Special.Text.Picker);
  903.  
  904.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  905.                                                     *MsgCode    = 0;
  906.                                                     *MsgGadget    = Gadget;
  907.                                                 }
  908.                                                 else
  909.                                                     Swallow = TRUE;
  910.                                             }
  911.                                             else
  912.                                                 Swallow = TRUE;
  913.  
  914.                                             FoundIt = TRUE;
  915.  
  916.                                             break;
  917.  
  918.                                         case NUMBER_KIND:
  919.  
  920.                                             Swallow = TRUE;
  921.                                             FoundIt = TRUE;
  922.  
  923.                                             break;
  924.  
  925.                                         case CYCLE_KIND:
  926.  
  927.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  928.                                             {
  929.                                                 if(Forward)
  930.                                                     NewValue++;
  931.                                                 else
  932.                                                     NewValue--;
  933.  
  934.                                                 NewValue = CurrentWrap(Node,NewValue);
  935.  
  936.                                                 LTP_BlinkButton(Handle,Gadget);
  937.  
  938.                                                 GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  939.                                                     GTCY_Active,Node->Current = NewValue,
  940.                                                 TAG_DONE);
  941.  
  942.                                                 LTP_PutStorage(Node);
  943.  
  944.                                                 *MsgClass    = IDCMP_GADGETUP;
  945.                                                 *MsgCode    = Node->Current;
  946.                                                 *MsgGadget    = Gadget;
  947.  
  948.                                                 if(Node->Special.Cycle.AutoPageID != -1)
  949.                                                 {
  950.                                                     *MsgClass = NULL;
  951.  
  952.                                                     if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  953.                                                         *MsgClass = IDCMP_CLOSEWINDOW;
  954.                                                 }
  955.                                             }
  956.                                             else
  957.                                                 Swallow = TRUE;
  958.  
  959.                                             FoundIt = TRUE;
  960.  
  961.                                             break;
  962.  
  963.                                         case PALETTE_KIND:
  964.  
  965.                                             if(!KeyUp)
  966.                                             {
  967.                                                 if(Node->Special.Palette.UsePicker)
  968.                                                 {
  969.                                                     if(!(MsgQualifier & IEQUALIFIER_REPEAT))
  970.                                                     {
  971.                                                         LTP_BlinkButton(Handle,Node->Special.Palette.Picker);
  972.  
  973.                                                         *MsgClass    = IDCMP_IDCMPUPDATE;
  974.                                                         *MsgCode    = 0;
  975.                                                         *MsgGadget    = Gadget;
  976.                                                     }
  977.                                                     else
  978.                                                         Swallow = TRUE;
  979.  
  980.                                                     FoundIt = TRUE;
  981.  
  982.                                                     break;
  983.                                                 }
  984.  
  985.                                                 if(Node->Special.Palette.TranslateBack)
  986.                                                 {
  987.                                                     LONG Index = Node->Special.Palette.TranslateBack[Node->Current];
  988.  
  989.                                                     if(Index < Node->Min)
  990.                                                         Index = Node->Min;
  991.                                                     else
  992.                                                     {
  993.                                                         if(Index > Node->Max)
  994.                                                             Index = Node->Max;
  995.                                                     }
  996.  
  997.                                                     if(Forward)
  998.                                                         Index++;
  999.                                                     else
  1000.                                                         Index--;
  1001.  
  1002.                                                     if(Index < Node->Min)
  1003.                                                         Index = Node->Min;
  1004.                                                     else
  1005.                                                     {
  1006.                                                         if(Index > Node->Max)
  1007.                                                             Index = Node->Max;
  1008.                                                     }
  1009.  
  1010.                                                     NewValue = Node->Special.Palette.ColourTable[Index];
  1011.                                                 }
  1012.                                                 else
  1013.                                                 {
  1014.                                                     if(Forward)
  1015.                                                         NewValue++;
  1016.                                                     else
  1017.                                                         NewValue--;
  1018.                                                 }
  1019.  
  1020.                                                 if(CurrentInBounds(Node,NewValue))
  1021.                                                 {
  1022.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1023.                                                         GTPA_Color,Node->Current = NewValue,
  1024.                                                     TAG_DONE);
  1025.  
  1026.                                                     LTP_PutStorage(Node);
  1027.  
  1028.                                                     *MsgClass    = IDCMP_GADGETUP;
  1029.                                                     *MsgCode    = Node->Current;
  1030.                                                     *MsgGadget    = Gadget;
  1031.                                                 }
  1032.                                                 else
  1033.                                                     Swallow = TRUE;
  1034.                                             }
  1035.                                             else
  1036.                                                 Swallow = TRUE;
  1037.  
  1038.                                             FoundIt = TRUE;
  1039.  
  1040.                                             break;
  1041.  
  1042.                                         case SLIDER_KIND:
  1043.  
  1044.                                             if(KeyUp)
  1045.                                             {
  1046.                                                 *MsgClass    = IDCMP_GADGETUP;
  1047.                                                 *MsgCode    = Node->Current;
  1048.                                                 *MsgGadget    = Gadget;
  1049.                                             }
  1050.                                             else
  1051.                                             {
  1052.                                                 if(Forward)
  1053.                                                     NewValue++;
  1054.                                                 else
  1055.                                                     NewValue--;
  1056.  
  1057.                                                 if(CurrentInBounds(Node,NewValue))
  1058.                                                 {
  1059.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1060.                                                         GTSL_Level,Node->Current = NewValue,
  1061.                                                     TAG_DONE);
  1062.  
  1063.                                                     LTP_PutStorage(Node);
  1064.  
  1065.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1066.                                                     *MsgCode    = Node->Current;
  1067.                                                     *MsgGadget    = Gadget;
  1068.                                                 }
  1069.                                                 else
  1070.                                                     Swallow = TRUE;
  1071.                                             }
  1072.  
  1073.                                             FoundIt = TRUE;
  1074.  
  1075.                                             break;
  1076.  
  1077. #ifdef DO_LEVEL_KIND
  1078.                                         case LEVEL_KIND:
  1079.  
  1080.                                             if(KeyUp)
  1081.                                             {
  1082.                                                 *MsgClass    = IDCMP_GADGETUP;
  1083.                                                 *MsgCode    = Node->Current;
  1084.                                                 *MsgGadget    = Gadget;
  1085.  
  1086.                                                 LTP_PutStorage(Node);
  1087.                                             }
  1088.                                             else
  1089.                                             {
  1090.                                                 if(Forward)
  1091.                                                     NewValue++;
  1092.                                                 else
  1093.                                                     NewValue--;
  1094.  
  1095.                                                 if(CurrentInBounds(Node,NewValue))
  1096.                                                 {
  1097.                                                     LT_SetAttributes(Handle,Node->ID,
  1098.                                                         LAPR_Object,    Node,
  1099.                                                         LAVL_Level,        NewValue,
  1100.                                                     TAG_DONE);
  1101.  
  1102.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1103.                                                     *MsgCode    = NewValue;
  1104.                                                     *MsgGadget    = Gadget;
  1105.                                                 }
  1106.                                                 else
  1107.                                                     Swallow = TRUE;
  1108.                                             }
  1109.  
  1110.                                             FoundIt = TRUE;
  1111.  
  1112.                                             break;
  1113. #endif    /* DO_LEVEL_KIND */
  1114.  
  1115.                                         case SCROLLER_KIND:
  1116.  
  1117.                                             if(KeyUp)
  1118.                                             {
  1119.                                                 *MsgClass    = IDCMP_GADGETUP;
  1120.                                                 *MsgCode    = Node->Current;
  1121.                                                 *MsgGadget    = Gadget;
  1122.                                             }
  1123.                                             else
  1124.                                             {
  1125.                                                 if(Forward)
  1126.                                                     NewValue++;
  1127.                                                 else
  1128.                                                     NewValue--;
  1129.  
  1130.                                                 if(CurrentInBounds(Node,NewValue))
  1131.                                                 {
  1132.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1133.                                                         GTSC_Top,Node->Current = NewValue,
  1134.                                                     TAG_DONE);
  1135.  
  1136.                                                     LTP_PutStorage(Node);
  1137.  
  1138.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1139.                                                     *MsgCode    = Node->Current;
  1140.                                                     *MsgGadget    = Gadget;
  1141.                                                 }
  1142.                                                 else
  1143.                                                     Swallow = TRUE;
  1144.                                             }
  1145.  
  1146.                                             FoundIt = TRUE;
  1147.  
  1148.                                             break;
  1149.  
  1150.                                         case STRING_KIND:
  1151.                                         case FRACTION_KIND:
  1152.                                         case PASSWORD_KIND:
  1153.  
  1154.                                             if(!KeyUp)
  1155.                                             {
  1156.                                                 if(Node->Special.String.Picker && !Forward)
  1157.                                                 {
  1158.                                                     LTP_BlinkButton(Handle,Node->Special.String.Picker);
  1159.  
  1160.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  1161.                                                     *MsgCode    = 0;
  1162.                                                     *MsgGadget    = Gadget;
  1163.                                                 }
  1164.                                                 else
  1165.                                                 {
  1166.                                                     ActivateGadget(Gadget,Handle->Window,NULL);
  1167.  
  1168.                                                     *MsgClass    = IDCMP_GADGETDOWN;
  1169.                                                     *MsgCode    = 0;
  1170.                                                     *MsgGadget    = Gadget;
  1171.  
  1172.                                                     Handle->Previous = Gadget;
  1173.                                                 }
  1174.                                             }
  1175.                                             else
  1176.                                                 Swallow = TRUE;
  1177.  
  1178.                                             FoundIt = TRUE;
  1179.  
  1180.                                             break;
  1181.  
  1182.                                         case INTEGER_KIND:
  1183.  
  1184.                                             if(!KeyUp)
  1185.                                             {
  1186.                                                 if(Node->Special.Integer.UseIncrementers)
  1187.                                                 {
  1188.                                                     ObjectNode *incNode,*Parent;
  1189.                                                     struct Gadget *Incrementer;
  1190.                                                     LONG Number;
  1191.  
  1192.                                                     Parent = (ObjectNode *)Gadget->UserData;
  1193.  
  1194.                                                     if(Forward)
  1195.                                                     {
  1196.                                                         incNode = Node->Special.Integer.RightIncrementer->UserData;
  1197.  
  1198.                                                         Incrementer = Node->Special.Integer.RightIncrementer;
  1199.                                                     }
  1200.                                                     else
  1201.                                                     {
  1202.                                                         incNode = Node->Special.Integer.LeftIncrementer->UserData;
  1203.  
  1204.                                                         Incrementer = Node->Special.Integer.LeftIncrementer;
  1205.                                                     }
  1206.  
  1207.                                                     if(Parent->Special.Integer.IncrementerHook)
  1208.                                                         Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),incNode->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1209.                                                     else
  1210.                                                         Number = ((LONG)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE)) + incNode->Special.Incrementer.Amount;
  1211.  
  1212.                                                     if(Node->Min <= Number && Number <= Node->Max && Number != Parent->Special.Integer.Number)
  1213.                                                     {
  1214.                                                         LTP_BlinkButton(Handle,Incrementer);
  1215.  
  1216.                                                         LT_SetAttributes(Handle,Parent->ID,
  1217.                                                             LAPR_Object,    Parent,
  1218.                                                             GTIN_Number,    Number,
  1219.                                                         TAG_DONE);
  1220.  
  1221.                                                         *MsgClass = IDCMP_GADGETUP;
  1222.                                                     }
  1223.                                                 }
  1224.                                                 else
  1225.                                                 {
  1226.                                                     ActivateGadget(Gadget,Handle->Window,NULL);
  1227.  
  1228.                                                     *MsgClass = IDCMP_GADGETDOWN;
  1229.                                                 }
  1230.  
  1231.                                                 *MsgCode    = 0;
  1232.                                                 *MsgGadget    = Gadget;
  1233.  
  1234.                                                 Handle->Previous = Gadget;
  1235.                                             }
  1236.                                             else
  1237.                                                 Swallow = TRUE;
  1238.  
  1239.                                             FoundIt = TRUE;
  1240.  
  1241.                                             break;
  1242.  
  1243.                                         case BUTTON_KIND:
  1244.  
  1245.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  1246.                                             {
  1247.                                                 LTP_BlinkButton(Handle,Gadget);
  1248.  
  1249.                                                 *MsgClass    = IDCMP_GADGETUP;
  1250.                                                 *MsgCode    = 0;
  1251.                                                 *MsgGadget    = Gadget;
  1252.                                             }
  1253.                                             else
  1254.                                                 Swallow = TRUE;
  1255.  
  1256.                                             FoundIt = TRUE;
  1257.  
  1258.                                             break;
  1259.                                     }
  1260.  
  1261.                                     if(Swallow)
  1262.                                     {
  1263.                                         if(Handle->RawKeyFilter)
  1264.                                             *MsgClass = NULL;
  1265.                                     }
  1266.                                 }
  1267.                             }
  1268.                         }
  1269.                     }
  1270.                 }
  1271.  
  1272.                 if(FoundIt)
  1273.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1274.             }
  1275.  
  1276.             Handle->ActiveFrame = NULL;
  1277.  
  1278.             break;
  1279.         }
  1280.  
  1281.         case IDCMP_GADGETDOWN:
  1282.  
  1283.             if(GETOBJECT((*MsgGadget),Node))
  1284.             {
  1285.                 if(Node->Type != LISTVIEW_KIND)
  1286.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1287.  
  1288.                 Handle->ActiveFrame = NULL;
  1289.  
  1290.                 switch(Node->Type)
  1291.                 {
  1292. #ifdef DO_LEVEL_KIND
  1293.                     case LEVEL_KIND:
  1294.  
  1295.                         Handle->CurrentLevel = Node;
  1296.  
  1297.                         *MsgCode = Node->Current;
  1298.  
  1299.                         break;
  1300. #endif    /* DO_LEVEL_KIND */
  1301.                     case STRING_KIND:
  1302.                     case FRACTION_KIND:
  1303.                     case INTEGER_KIND:
  1304.                     case PASSWORD_KIND:
  1305.  
  1306.                         Handle->Previous = *MsgGadget;
  1307.                         break;
  1308. #ifdef DO_TAPEDECK_KIND
  1309.                     case TAPEDECK_KIND:
  1310.  
  1311.                         if(Node->Special.TapeDeck.Tick)
  1312.                         {
  1313.                             Handle->ActiveIncrementer        = Node;
  1314.                             Handle->IncrementerCountdown    = 2;
  1315.                             Handle->IncrementerAccelerate    = 10;
  1316.                             Handle->IncrementerIncrement    = 1;
  1317.  
  1318.                             *MsgClass    = IDCMP_GADGETUP;
  1319.                             *MsgCode    = 0;
  1320.                         }
  1321.                         else
  1322.                         {
  1323.                             if(Node->Special.TapeDeck.Toggle)
  1324.                             {
  1325.                                 if((*MsgGadget)->Flags & GFLG_SELECTED)
  1326.                                     *MsgCode = TRUE;
  1327.                                 else
  1328.                                     *MsgCode = FALSE;
  1329.  
  1330.                                 Node->Current = *MsgCode;
  1331.  
  1332.                                 LTP_PutStorage(Node);
  1333.  
  1334.                                 if(Handle->Previous && !Node->PageSelector)
  1335.                                     Activate = TRUE;
  1336.  
  1337.                                 *MsgClass = IDCMP_GADGETUP;
  1338.                             }
  1339.                         }
  1340.  
  1341.                         break;
  1342. #endif    /* DO_TAPEDECK_KIND */
  1343.                     case MX_KIND:
  1344.  
  1345.                         if(!V39 && Node->Disabled)
  1346.                         {
  1347.                             GT_SetGadgetAttrs(*MsgGadget,Handle->Window,NULL,
  1348.                                 GTMX_Active,Node->Current,
  1349.                             TAG_DONE);
  1350.  
  1351.                             *MsgClass = NULL;
  1352.                         }
  1353.                         else
  1354.                         {
  1355.                             Node->Current = *MsgCode;
  1356.  
  1357.                             LTP_PutStorage(Node);
  1358.  
  1359.                             if(Node->Special.Radio.AutoPageID != -1)
  1360.                             {
  1361.                                 *MsgClass = NULL;
  1362.  
  1363.                                 if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  1364.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1365.                             }
  1366.  
  1367.                             if(Handle->Previous && !Node->PageSelector)
  1368.                                 Activate = TRUE;
  1369.                         }
  1370.  
  1371.                         break;
  1372.  
  1373.                     case SLIDER_KIND:
  1374.  
  1375.                         if(Node->Min < 0)
  1376.                             Node->Current = (WORD)*MsgCode;
  1377.                         else
  1378.                             Node->Current = *MsgCode;
  1379.  
  1380.                         LTP_PutStorage(Node);
  1381.  
  1382.                         if(Handle->Previous && !Node->PageSelector)
  1383.                             Activate = TRUE;
  1384.  
  1385.                         break;
  1386.  
  1387.                     case SCROLLER_KIND:
  1388.  
  1389.                         Node->Current = *MsgCode;
  1390.  
  1391.                         LTP_PutStorage(Node);
  1392.  
  1393.                         if(Handle->Previous && !Node->PageSelector)
  1394.                             Activate = TRUE;
  1395.  
  1396.                         break;
  1397.  
  1398.                     case INCREMENTER_KIND:
  1399.  
  1400.                         Handle->ActiveIncrementer        = Node;
  1401.                         Handle->IncrementerCountdown    = 6;
  1402.                         Handle->IncrementerAccelerate    = 10;
  1403.                         Handle->IncrementerIncrement    = 1;
  1404.  
  1405.                         *MsgClass    = IDCMP_GADGETUP;
  1406.                         *MsgCode    = 0;
  1407.                         *MsgGadget    = Node->Special.Incrementer.Parent;
  1408.  
  1409.                         /* ALWAYS */
  1410.                         {
  1411.                             struct ObjectNode *Parent;
  1412.                             LONG Number;
  1413.  
  1414.                             Parent = (ObjectNode *)(*MsgGadget)->UserData;
  1415.  
  1416.                             if(Parent->Special.Integer.IncrementerHook)
  1417.                                 Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),Node->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1418.                             else
  1419.                                 Number = LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE) + Node->Special.Incrementer.Amount;
  1420.  
  1421.                             if(Number >= Parent->Min && Number <= Parent->Max)
  1422.                                 LT_SetAttributes(Handle,Parent->ID,LAPR_Object,Parent,GTIN_Number,Number,TAG_DONE);
  1423.                             else
  1424.                                 *MsgClass = NULL;
  1425.                         }
  1426.  
  1427.                         break;
  1428.                 }
  1429.             }
  1430.  
  1431.             break;
  1432.  
  1433.         case IDCMP_MOUSEBUTTONS:
  1434.         {
  1435.             ObjectNode *Node;
  1436.             LONG x,y;
  1437.  
  1438.             x = Handle->Window->MouseX;
  1439.             y = Handle->Window->MouseY;
  1440.  
  1441.             Node = LTP_FindNode_Position(Handle->TopGroup,x,y);
  1442.  
  1443.             if(((*MsgCode) & IECODE_UP_PREFIX) && Handle->Previous)
  1444.                 Activate = TRUE;
  1445.  
  1446.             if(Node && !Node->Disabled)
  1447.             {
  1448.                 if(*MsgCode == SELECTDOWN)
  1449.                 {
  1450.                     switch(Node->Type)
  1451.                     {
  1452.                         case CHECKBOX_KIND:
  1453.  
  1454.                             Node->Current = !Node->Current;
  1455.  
  1456.                             LTP_PutStorage(Node);
  1457.  
  1458.                             GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1459.                                 GTCB_Checked,Node->Current,
  1460.                             TAG_DONE);
  1461.  
  1462.                             *MsgClass    = IDCMP_GADGETUP;
  1463.                             *MsgCode    = Node->Current;
  1464.                             *MsgGadget    = Node->Host;
  1465.  
  1466.                             break;
  1467.  
  1468.                         case MX_KIND:
  1469.                         {
  1470.                             LONG Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1471.  
  1472.                             if(Index != -1)
  1473.                             {
  1474.                                 Node->Current = Index;
  1475.  
  1476.                                 GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1477.                                     GTMX_Active,Index,
  1478.                                 TAG_DONE);
  1479.  
  1480.                                 LTP_PutStorage(Node);
  1481.  
  1482.                                 *MsgClass    = IDCMP_GADGETDOWN;
  1483.                                 *MsgCode    = Index;
  1484.                                 *MsgGadget    = Node->Host;
  1485.  
  1486.                                 if(Node->Special.Cycle.AutoPageID != -1)
  1487.                                     *MsgClass = NULL;
  1488.  
  1489.                                 if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1490.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1491.                             }
  1492.  
  1493.                             break;
  1494.                         }
  1495.  
  1496.                         case FRAME_KIND:
  1497.  
  1498.                             if(Node->Special.Frame.GenerateEvents)
  1499.                             {
  1500.                                 if(Node->Special.Frame.DrawBox)
  1501.                                 {
  1502.                                     if(x < Node->Left + 2 || x >= Node->Left + Node->Width - 2 || y < Node->Top + 1 || y >= Node->Top + Node->Height - 2)
  1503.                                         break;
  1504.                                 }
  1505.  
  1506.                                 *MsgClass    = IDCMP_GADGETDOWN;
  1507.                                 *MsgGadget    = &Node->Special.Frame.Dummy;
  1508.  
  1509.                                 Handle->ActiveFrame = Node;
  1510.                             }
  1511.  
  1512.                             break;
  1513.                     }
  1514.                 }
  1515.  
  1516.                 if(*MsgCode == SELECTUP)
  1517.                 {
  1518.                         // Now this is a real kludge; as of v37 the
  1519.                         // MX_KIND labels are not part of the gadget
  1520.                         // itself and a plain SELECTDOWN mouse event
  1521.                         // is sent as soon as the user clicks on it.
  1522.                         // This changed with v39 which presumably had
  1523.                         // some code in there to map mouse clicks on
  1524.                         // the gadget labels to proper buttonpress
  1525.                         // events. Now, try as you might the click is
  1526.                         // swallowed and we have to do with the
  1527.                         // SELECTUP, sigh...
  1528.  
  1529.                     if(V39 && Node->Type == MX_KIND)
  1530.                     {
  1531.                         LONG Index;
  1532.  
  1533.                         Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1534.  
  1535.                         if(Index != -1)
  1536.                         {
  1537.                             GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1538.                                 GTMX_Active,Index,
  1539.                             TAG_DONE);
  1540.  
  1541.                             Node->Current = Index;
  1542.  
  1543.                             LTP_PutStorage(Node);
  1544.  
  1545.                             *MsgClass    = IDCMP_GADGETDOWN;
  1546.                             *MsgCode    = Index;
  1547.                             *MsgGadget    = Node->Host;
  1548.  
  1549.                             if(Node->Special.Cycle.AutoPageID != -1)
  1550.                                 *MsgClass = NULL;
  1551.  
  1552.                             if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1553.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1554.                         }
  1555.                     }
  1556.  
  1557.                     if(Handle->ActiveIncrementer)
  1558.                     {
  1559.                         if(Handle->ActiveIncrementer->Type == TAPEDECK_KIND && Handle->ActiveIncrementer ->Special.TapeDeck.Tick)
  1560.                         {
  1561.                             Handle->ActiveIncrementer = NULL;
  1562.  
  1563.                             *MsgClass    = IDCMP_GADGETUP;
  1564.                             *MsgCode    = 1;
  1565.                         }
  1566.                         else
  1567.                         {
  1568.                             if(((ObjectNode *)Handle->ActiveIncrementer->Special.Incrementer.Parent->UserData)->Type == INTEGER_KIND)
  1569.                             {
  1570.                                 *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  1571.                                 *MsgClass    = IDCMP_GADGETUP;
  1572.                                 *MsgCode    = 1;
  1573.                             }
  1574.  
  1575.                             Handle->ActiveIncrementer = NULL;
  1576.                         }
  1577.                     }
  1578.  
  1579.                     if(Handle->ActiveFrame)
  1580.                     {
  1581.                         *MsgClass    = IDCMP_GADGETUP;
  1582.                         *MsgGadget    = &Node->Special.Frame.Dummy;
  1583.  
  1584.                         Handle->ActiveFrame = NULL;
  1585.                     }
  1586.                 }
  1587.             }
  1588.  
  1589.             break;
  1590.         }
  1591.  
  1592.         case IDCMP_GADGETUP:
  1593.  
  1594. #ifdef DO_LEVEL_KIND
  1595.             Handle->CurrentLevel = NULL;
  1596. #endif    /* DO_LEVEL_KIND */
  1597.  
  1598.             Handle->ActiveFrame = NULL;
  1599.  
  1600.             if(GETOBJECT((*MsgGadget),Node))
  1601.             {
  1602.                 if(Node->Type != LISTVIEW_KIND)
  1603.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1604.  
  1605.                 switch(Node->Type)
  1606.                 {
  1607.                     case PASSWORD_KIND:
  1608.                     case STRING_KIND:
  1609.                     case FRACTION_KIND:
  1610.  
  1611.                         LTP_PutStorage(Node);
  1612.  
  1613.                         if(*MsgCode == 0x5F && Handle->HelpHook)
  1614.                         {
  1615.                             struct HelpMsg Message;
  1616.                             struct IBox Box;
  1617.  
  1618.                             Message.ObjectID = Node->ID;
  1619.  
  1620.                             Box.Left    = Node->Left;
  1621.                             Box.Top        = Node->Top;
  1622.                             Box.Width    = Node->Width;
  1623.                             Box.Height    = Node->Height;
  1624.  
  1625.                             Message.Handle = Handle;
  1626.  
  1627.                             CallHookPkt(Handle->HelpHook,&Message,&Box);
  1628.  
  1629.                             *MsgClass = NULL;
  1630.                         }
  1631.                         else
  1632.                             Handle->Previous = NULL;
  1633.  
  1634.                         break;
  1635.  
  1636.                     case INTEGER_KIND:
  1637.                     {
  1638.                         struct StringInfo *StringInfo = (struct StringInfo *)(*MsgGadget)->SpecialInfo;
  1639.                         LONG Contents = StringInfo->LongInt;
  1640.  
  1641.                         if(Contents < Node->Min)
  1642.                             Contents = Node->Min;
  1643.                         else
  1644.                         {
  1645.                             if(Contents > Node->Max)
  1646.                                 Contents = Node->Max;
  1647.                         }
  1648.  
  1649.                         LT_SetAttributes(Handle,(*MsgGadget)->GadgetID,GTIN_Number,Contents,TAG_DONE);
  1650.  
  1651.                         LTP_PutStorage(Node);
  1652.  
  1653.                         if(*MsgCode == 0x5F && Handle->HelpHook)
  1654.                         {
  1655.                             struct HelpMsg Message;
  1656.                             struct IBox Box;
  1657.  
  1658.                             Message.ObjectID = Node->ID;
  1659.  
  1660.                             Box.Left    = Node->Left;
  1661.                             Box.Top        = Node->Top;
  1662.                             Box.Width    = Node->Width;
  1663.                             Box.Height    = Node->Height;
  1664.  
  1665.                             Message.Handle = Handle;
  1666.  
  1667.                             CallHookPkt(Handle->HelpHook,&Message,&Box);
  1668.  
  1669.                             *MsgClass = NULL;
  1670.                         }
  1671.                         else
  1672.                             Handle->Previous = NULL;
  1673.  
  1674.                         break;
  1675.                     }
  1676.  
  1677.                     case CHECKBOX_KIND:
  1678.  
  1679.                         if(!V39)
  1680.                         {
  1681.                             if((*MsgGadget)->Flags & GFLG_SELECTED)
  1682.                                 *MsgCode = TRUE;
  1683.                             else
  1684.                                 *MsgCode = FALSE;
  1685.                         }
  1686.  
  1687.                         Node->Current = *MsgCode;
  1688.  
  1689.                         LTP_PutStorage(Node);
  1690.  
  1691.                         if(Handle->Previous && !Node->PageSelector)
  1692.                             Activate = TRUE;
  1693.  
  1694.                         break;
  1695. #ifdef DO_TAPEDECK_KIND
  1696.                     case TAPEDECK_KIND:
  1697.  
  1698.                         if(Node->Special.TapeDeck.Tick)
  1699.                         {
  1700.                             Handle->ActiveIncrementer = NULL;
  1701.  
  1702.                             *MsgClass    = IDCMP_GADGETUP;
  1703.                             *MsgCode    = 1;
  1704.                         }
  1705.                         else
  1706.                         {
  1707.                             if(Node->Special.TapeDeck.Toggle)
  1708.                             {
  1709.                                 if((*MsgGadget)->Flags & GFLG_SELECTED)
  1710.                                     *MsgCode = TRUE;
  1711.                                 else
  1712.                                     *MsgCode = FALSE;
  1713.  
  1714.                                 Node->Current = *MsgCode;
  1715.  
  1716.                                 LTP_PutStorage(Node);
  1717.                             }
  1718.                         }
  1719.  
  1720.                         if(Handle->Previous && !Node->PageSelector)
  1721.                             Activate = TRUE;
  1722.  
  1723.                         break;
  1724. #endif    /* DO_TAPEDECK_KIND */
  1725. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1726.                     case POPUP_KIND:
  1727.  
  1728.                         Node->Current = *MsgCode;
  1729.  
  1730.                         LTP_PutStorage(Node);
  1731.  
  1732.                         if(Handle->Previous && !Node->PageSelector)
  1733.                             Activate = TRUE;
  1734.  
  1735.                         if(Node->Special.Popup.AutoPageID != -1)
  1736.                         {
  1737.                             *MsgClass = NULL;
  1738.  
  1739.                             if(!LTP_NotifyPager(Handle,Node->Special.Popup.AutoPageID,Node->Current))
  1740.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1741.                         }
  1742.  
  1743.                         break;
  1744. #endif
  1745.  
  1746. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1747.                     case TAB_KIND:
  1748.  
  1749.                         Node->Current = *MsgCode;
  1750.  
  1751.                         LTP_PutStorage(Node);
  1752.  
  1753.                         if(Handle->Previous && !Node->PageSelector)
  1754.                             Activate = TRUE;
  1755.  
  1756.                         if(Node->Special.Tab.AutoPageID != -1)
  1757.                         {
  1758.                             *MsgClass = NULL;
  1759.  
  1760.                             if(!LTP_NotifyPager(Handle,Node->Special.Tab.AutoPageID,Node->Current))
  1761.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1762.                         }
  1763.  
  1764.                         break;
  1765. #endif
  1766.                     case CYCLE_KIND:
  1767.  
  1768.                         Node->Current = *MsgCode;
  1769.  
  1770.                         LTP_PutStorage(Node);
  1771.  
  1772.                         if(Handle->Previous && !Node->PageSelector)
  1773.                             Activate = TRUE;
  1774.  
  1775.                         if(Node->Special.Cycle.AutoPageID != -1)
  1776.                         {
  1777.                             *MsgClass = NULL;
  1778.  
  1779.                             if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1780.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1781.                         }
  1782.  
  1783.                         break;
  1784.  
  1785.                     case PALETTE_KIND:
  1786.  
  1787.                         Node->Current = *MsgCode;
  1788.  
  1789.                         LTP_PutStorage(Node);
  1790.  
  1791.                         if(Handle->Previous && !Node->PageSelector)
  1792.                             Activate = TRUE;
  1793.  
  1794.                         break;
  1795.  
  1796.                     case MX_KIND:
  1797.  
  1798.                         if(!V39 && Node->Disabled)
  1799.                         {
  1800.                             GT_SetGadgetAttrs(*MsgGadget,Handle->Window,NULL,
  1801.                                 GTMX_Active,Node->Current,
  1802.                             TAG_DONE);
  1803.  
  1804.                             *MsgClass = NULL;
  1805.                         }
  1806.                         else
  1807.                         {
  1808.                             Node->Current = *MsgCode;
  1809.  
  1810.                             LTP_PutStorage(Node);
  1811.  
  1812.                             if(Node->Special.Radio.AutoPageID != -1)
  1813.                             {
  1814.                                 *MsgClass = NULL;
  1815.  
  1816.                                 if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  1817.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1818.                             }
  1819.  
  1820.                             if(Handle->Previous && !Node->PageSelector)
  1821.                                 Activate = TRUE;
  1822.                         }
  1823.  
  1824.                         break;
  1825.  
  1826.                     case SLIDER_KIND:
  1827.  
  1828.                         if(Node->Min < 0)
  1829.                             Node->Current = (WORD)*MsgCode;
  1830.                         else
  1831.                             Node->Current = *MsgCode;
  1832.  
  1833.                         LTP_PutStorage(Node);
  1834.  
  1835.                         if(Handle->Previous && !Node->PageSelector)
  1836.                             Activate = TRUE;
  1837.  
  1838.                         break;
  1839. #ifdef DO_LEVEL_KIND
  1840.                     case LEVEL_KIND:
  1841.  
  1842.                         *MsgCode    = Node->Current;
  1843.                         *MsgGadget    = Node->Host;
  1844.  
  1845.                         LTP_PutStorage(Node);
  1846.  
  1847.                         break;
  1848. #endif    /* DO_LEVEL_KIND */
  1849.                     case SCROLLER_KIND:
  1850.  
  1851.                         Node->Current = *MsgCode;
  1852.  
  1853.                         LTP_PutStorage(Node);
  1854.  
  1855.                         if(Handle->Previous && !Node->PageSelector)
  1856.                             Activate = TRUE;
  1857.  
  1858.                         break;
  1859.  
  1860.                     case PICKER_KIND:
  1861.  
  1862.                         *MsgClass    = IDCMP_IDCMPUPDATE;
  1863.                         *MsgCode    = 0;
  1864.                         *MsgGadget    = Node->Special.Picker.Parent;
  1865.  
  1866.                         if(Handle->Previous && !Node->PageSelector)
  1867.                             Activate = TRUE;
  1868.  
  1869.                         break;
  1870.  
  1871.                     case INCREMENTER_KIND:
  1872.  
  1873.                         if(((ObjectNode *)Handle->ActiveIncrementer->Special.Incrementer.Parent->UserData)->Type == INTEGER_KIND)
  1874.                         {
  1875.                             *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  1876.                             *MsgClass    = IDCMP_GADGETUP;
  1877.                             *MsgCode    = 1;
  1878.                         }
  1879.  
  1880.                         Handle->ActiveIncrementer = NULL;
  1881.                         break;
  1882.  
  1883.                     case LISTVIEW_KIND:
  1884.  
  1885.                         if(Node->Current != *MsgCode || Node != Handle->ClickObject)
  1886.                         {
  1887.                             CurrentTime(&Handle->ClickSeconds,&Handle->ClickMicros);
  1888.  
  1889.                             Handle->ClickObject = Node;
  1890.                         }
  1891.                         else
  1892.                         {
  1893.                             ULONG Seconds,Micros;
  1894.  
  1895.                             CurrentTime(&Seconds,&Micros);
  1896.  
  1897.                             if(DoubleClick(Handle->ClickSeconds,Handle->ClickMicros,Seconds,Micros))
  1898.                                 *MsgClass = IDCMP_IDCMPUPDATE;
  1899.  
  1900.                             Handle->ClickSeconds    = Seconds;
  1901.                             Handle->ClickMicros    = Micros;
  1902.                         }
  1903.  
  1904.                         Node->Current = *MsgCode;
  1905.  
  1906.                         LTP_PutStorage(Node);
  1907.  
  1908.                         if(Node->Special.List.AutoPageID != -1)
  1909.                             *MsgClass = NULL;
  1910.  
  1911.                         if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  1912.                             *MsgClass = IDCMP_CLOSEWINDOW;
  1913.  
  1914.                         if(Node->Special.List.Link)
  1915.                         {
  1916.                             Handle->Previous = Node->Special.List.Link;
  1917.  
  1918.                             if(!Node->PageSelector)
  1919.                                 Activate = TRUE;
  1920.                         }
  1921.                         else
  1922.                         {
  1923.                             if(Handle->Previous && !Node->PageSelector)
  1924.                                 Activate = TRUE;
  1925.                         }
  1926.  
  1927.                         break;
  1928.  
  1929.                     default:
  1930.  
  1931.                         if(Handle->Previous && !Node->PageSelector)
  1932.                             Activate = TRUE;
  1933.  
  1934.                         break;
  1935.                 }
  1936.             }
  1937.  
  1938.             break;
  1939.  
  1940.         case IDCMP_MOUSEMOVE:
  1941.  
  1942. #ifdef DO_LEVEL_KIND
  1943.             if(Handle->CurrentLevel)
  1944.                 Node = Handle->CurrentLevel;
  1945.             else
  1946. #endif
  1947.                 GETOBJECT((*MsgGadget),Node);
  1948.  
  1949.             if(Node)
  1950.             {
  1951.                 if(Node->Type != LISTVIEW_KIND)
  1952.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1953.  
  1954.                 switch(Node->Type)
  1955.                 {
  1956.                     case SCROLLER_KIND:
  1957.  
  1958.                         Node->Current = *MsgCode;
  1959.  
  1960.                         LTP_PutStorage(Node);
  1961.  
  1962.                         break;
  1963.  
  1964.                     case SLIDER_KIND:
  1965.  
  1966.                         if(Node->Min < 0)
  1967.                             Node->Current = (WORD)*MsgCode;
  1968.                         else
  1969.                             Node->Current = *MsgCode;
  1970.  
  1971.                         LTP_PutStorage(Node);
  1972.  
  1973.                         break;
  1974. #ifdef DO_LEVEL_KIND
  1975.                     case LEVEL_KIND:
  1976.  
  1977.                         *MsgCode    = Node->Current;
  1978.                         *MsgGadget  = Node->Host;
  1979.  
  1980.                         LTP_PutStorage(Node);
  1981.  
  1982.                         break;
  1983. #endif    /* DO_LEVEL_KIND */
  1984.                 }
  1985.             }
  1986.  
  1987.             break;
  1988.  
  1989.         case IDCMP_ACTIVEWINDOW:
  1990.  
  1991.             if(Handle->Previous)
  1992.             {
  1993.                 Activate = TRUE;
  1994.  
  1995.                 *MsgClass    = IDCMP_GADGETDOWN;
  1996.                 *MsgCode    = 0;
  1997.                 *MsgGadget    = Handle->Previous;
  1998.             }
  1999.  
  2000.             break;
  2001.  
  2002.         case IDCMP_INACTIVEWINDOW:
  2003.  
  2004.             Handle->ActiveIncrementer = NULL;
  2005.             Handle->ActiveFrame = NULL;
  2006.             break;
  2007.     }
  2008.  
  2009.     if(Handle->AutoActivate && Activate && Handle->Previous)
  2010.     {
  2011.         if(GETOBJECT(Handle->Previous,Node))
  2012.         {
  2013.             if(!Node->Disabled)
  2014.             {
  2015.                 if(Node->Type == BOOPSI_KIND)
  2016.                 {
  2017.                     if(Node->Special.BOOPSI.ActivateHook)
  2018.                         CallHookPkt(Node->Special.BOOPSI.ActivateHook,(APTR)Handle,(APTR)Node->Host);
  2019.                 }
  2020.                 else
  2021.                     ActivateGadget(Handle->Previous,Handle->Window,NULL);
  2022.             }
  2023.         }
  2024.     }
  2025. }
  2026.